{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "7a5c2153",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "[![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/langchain-ai/langchain-academy/blob/main/module-4/research-assistant.ipynb) [![Open in LangChain Academy](https://cdn.prod.website-files.com/65b8cd72835ceeacd4449a53/66e9eba12c7b7688aa3dbb5e_LCA-badge-green.svg)](https://academy.langchain.com/courses/take/intro-to-langgraph/lessons/58239974-lesson-4-research-assistant)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "e0a5763f-5f45-4b8f-b3e2-480f46c5721b",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "# Research Assistant\n",
    "\n",
    "## Review\n",
    "\n",
    "We've covered a few major LangGraph themes:\n",
    "\n",
    "* Memory\n",
    "* Human-in-the-loop\n",
    "* Controllability\n",
    "\n",
    "Now, we'll bring these ideas together to tackle one of AI's most popular applications: research automation. \n",
    "\n",
    "Research is often laborious work offloaded to analysts. AI has considerable potential to assist with this.\n",
    "\n",
    "However, research demands customization: raw LLM outputs are often poorly suited for real-world decision-making workflows. \n",
    "\n",
    "Customized, AI-based [research and report generation](https://jxnl.co/writing/2024/06/05/predictions-for-the-future-of-rag/#reports-over-rag) workflows are a promising way to address this.\n",
    "\n",
    "## Goal\n",
    "\n",
    "Our goal is to build a lightweight, multi-agent system around chat models that customizes the research process.\n",
    "\n",
    "`Source Selection` \n",
    "* Users can choose any set of input sources for their research.\n",
    "  \n",
    "`Planning` \n",
    "* Users provide a topic, and the system generates a team of AI analysts, each focusing on one sub-topic.\n",
    "* `Human-in-the-loop` will be used to refine these sub-topics before research begins.\n",
    "  \n",
    "`LLM Utilization`\n",
    "* Each analyst will conduct in-depth interviews with an expert AI using the selected sources.\n",
    "* The interview will be a multi-turn conversation to extract detailed insights as shown in the [STORM](https://arxiv.org/abs/2402.14207) paper.\n",
    "* These interviews will be captured in a using `sub-graphs` with their internal state. \n",
    "   \n",
    "`Research Process`\n",
    "* Experts will gather information to answer analyst questions in `parallel`.\n",
    "* And all interviews will be conducted simultaneously through `map-reduce`.\n",
    "\n",
    "`Output Format` \n",
    "* The gathered insights from each interview will be synthesized into a final report.\n",
    "* We'll use customizable prompts for the report, allowing for a flexible output format. \n",
    "\n",
    "![Screenshot 2024-08-26 at 7.26.33 PM.png](https://cdn.prod.website-files.com/65b8cd72835ceeacd4449a53/66dbb164d61c93d48e604091_research-assistant1.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "f23991e9-51b3-4e9f-86a0-dec16aa7d1e6",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "%%capture --no-stderr\n",
    "%pip install --quiet -U langgraph langchain_openai langchain_community langchain_core tavily-python wikipedia"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "99a1c01d-87e1-4723-b83e-ebcf937fe914",
   "metadata": {},
   "source": [
    "## Setup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "ba917800-10e4-4e2a-8e9e-30893b731e97",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os, getpass\n",
    "\n",
    "def _set_env(var: str):\n",
    "    if not os.environ.get(var):\n",
    "        os.environ[var] = getpass.getpass(f\"{var}: \")\n",
    "\n",
    "_set_env(\"OPENAI_API_KEY\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "afe9ff57-0826-4669-b88b-4d0501a509f5",
   "metadata": {},
   "outputs": [],
   "source": [
    "from langchain_openai import ChatOpenAI\n",
    "llm = ChatOpenAI(model=\"gpt-4o\", temperature=0) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3419257b-2c6b-4d68-ae38-4a266cc02982",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "We'll use [LangSmith](https://docs.langchain.com/langsmith/home) for [tracing](https://docs.langchain.com/langsmith/observability-concepts)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "5102cf2e-0ca9-465b-9499-67abb8132e5d",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "_set_env(\"LANGSMITH_API_KEY\")\n",
    "os.environ[\"LANGSMITH_TRACING\"] = \"true\"\n",
    "os.environ[\"LANGSMITH_PROJECT\"] = \"langchain-academy\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f8fe5d93-e353-44bb-be3e-434654bcb7ea",
   "metadata": {},
   "source": [
    "## Generate Analysts: Human-In-The-Loop\n",
    "\n",
    "Create analysts and review them using human-in-the-loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "1eee8e60-e548-49b1-88ec-a4f3aef2174e",
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "from typing_extensions import TypedDict\n",
    "from pydantic import BaseModel, Field\n",
    "\n",
    "class Analyst(BaseModel):\n",
    "    affiliation: str = Field(\n",
    "        description=\"Primary affiliation of the analyst.\",\n",
    "    )\n",
    "    name: str = Field(\n",
    "        description=\"Name of the analyst.\"\n",
    "    )\n",
    "    role: str = Field(\n",
    "        description=\"Role of the analyst in the context of the topic.\",\n",
    "    )\n",
    "    description: str = Field(\n",
    "        description=\"Description of the analyst focus, concerns, and motives.\",\n",
    "    )\n",
    "    @property\n",
    "    def persona(self) -> str:\n",
    "        return f\"Name: {self.name}\\nRole: {self.role}\\nAffiliation: {self.affiliation}\\nDescription: {self.description}\\n\"\n",
    "\n",
    "class Perspectives(BaseModel):\n",
    "    analysts: List[Analyst] = Field(\n",
    "        description=\"Comprehensive list of analysts with their roles and affiliations.\",\n",
    "    )\n",
    "\n",
    "class GenerateAnalystsState(TypedDict):\n",
    "    topic: str # Research topic\n",
    "    max_analysts: int # Number of analysts\n",
    "    human_analyst_feedback: str # Human feedback\n",
    "    analysts: List[Analyst] # Analyst asking questions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "fd088ff5-4c75-412c-85f0-04afd0900bfc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from IPython.display import Image, display\n",
    "from langgraph.graph import START, END, StateGraph\n",
    "from langgraph.checkpoint.memory import MemorySaver\n",
    "from langchain_core.messages import AIMessage, HumanMessage, SystemMessage\n",
    "\n",
    "analyst_instructions=\"\"\"You are tasked with creating a set of AI analyst personas. Follow these instructions carefully:\n",
    "\n",
    "1. First, review the research topic:\n",
    "{topic}\n",
    "        \n",
    "2. Examine any editorial feedback that has been optionally provided to guide creation of the analysts: \n",
    "        \n",
    "{human_analyst_feedback}\n",
    "    \n",
    "3. Determine the most interesting themes based upon documents and / or feedback above.\n",
    "                    \n",
    "4. Pick the top {max_analysts} themes.\n",
    "\n",
    "5. Assign one analyst to each theme.\"\"\"\n",
    "\n",
    "def create_analysts(state: GenerateAnalystsState):\n",
    "    \n",
    "    \"\"\" Create analysts \"\"\"\n",
    "    \n",
    "    topic=state['topic']\n",
    "    max_analysts=state['max_analysts']\n",
    "    human_analyst_feedback=state.get('human_analyst_feedback', '')\n",
    "        \n",
    "    # Enforce structured output\n",
    "    structured_llm = llm.with_structured_output(Perspectives)\n",
    "\n",
    "    # System message\n",
    "    system_message = analyst_instructions.format(topic=topic,\n",
    "                                                            human_analyst_feedback=human_analyst_feedback, \n",
    "                                                            max_analysts=max_analysts)\n",
    "\n",
    "    # Generate question \n",
    "    analysts = structured_llm.invoke([SystemMessage(content=system_message)]+[HumanMessage(content=\"Generate the set of analysts.\")])\n",
    "    \n",
    "    # Write the list of analysis to state\n",
    "    return {\"analysts\": analysts.analysts}\n",
    "\n",
    "def human_feedback(state: GenerateAnalystsState):\n",
    "    \"\"\" No-op node that should be interrupted on \"\"\"\n",
    "    pass\n",
    "\n",
    "def should_continue(state: GenerateAnalystsState):\n",
    "    \"\"\" Return the next node to execute \"\"\"\n",
    "\n",
    "    # Check if human feedback\n",
    "    human_analyst_feedback=state.get('human_analyst_feedback', None)\n",
    "    if human_analyst_feedback:\n",
    "        return \"create_analysts\"\n",
    "    \n",
    "    # Otherwise end\n",
    "    return END\n",
    "\n",
    "# Add nodes and edges \n",
    "builder = StateGraph(GenerateAnalystsState)\n",
    "builder.add_node(\"create_analysts\", create_analysts)\n",
    "builder.add_node(\"human_feedback\", human_feedback)\n",
    "builder.add_edge(START, \"create_analysts\")\n",
    "builder.add_edge(\"create_analysts\", \"human_feedback\")\n",
    "builder.add_conditional_edges(\"human_feedback\", should_continue, [\"create_analysts\", END])\n",
    "\n",
    "# Compile\n",
    "memory = MemorySaver()\n",
    "graph = builder.compile(interrupt_before=['human_feedback'], checkpointer=memory)\n",
    "\n",
    "# View\n",
    "display(Image(graph.get_graph(xray=1).draw_mermaid_png()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "6c22cb05-c436-4358-8f7a-72d722f9b5cc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name: Dr. Emily Carter\n",
      "Affiliation: Tech Innovators Inc.\n",
      "Role: Technology Adoption Specialist\n",
      "Description: Dr. Carter focuses on the technological advancements and integration of new frameworks like LangGraph. Her primary concern is how these frameworks can enhance efficiency and innovation in software development. She is motivated by the potential of LangGraph to streamline processes and improve the adaptability of agent-based systems.\n",
      "--------------------------------------------------\n",
      "Name: Mr. John Smith\n",
      "Affiliation: Global Business Solutions\n",
      "Role: Business Strategy Analyst\n",
      "Description: Mr. Smith analyzes the strategic business benefits of adopting new technologies such as LangGraph. His focus is on the competitive advantage and cost-effectiveness that LangGraph can offer to businesses. He is particularly interested in how LangGraph can drive business growth and improve market positioning.\n",
      "--------------------------------------------------\n",
      "Name: Ms. Sarah Lee\n",
      "Affiliation: Data Security Alliance\n",
      "Role: Cybersecurity Expert\n",
      "Description: Ms. Lee is dedicated to understanding the security implications of adopting new frameworks like LangGraph. Her main concern is ensuring that the integration of LangGraph does not compromise data security. She is motivated by the need to maintain robust security measures while leveraging the benefits of advanced agent frameworks.\n",
      "--------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "# Input\n",
    "max_analysts = 3 \n",
    "topic = \"The benefits of adopting LangGraph as an agent framework\"\n",
    "thread = {\"configurable\": {\"thread_id\": \"1\"}}\n",
    "\n",
    "# Run the graph until the first interruption\n",
    "for event in graph.stream({\"topic\":topic,\"max_analysts\":max_analysts,}, thread, stream_mode=\"values\"):\n",
    "    # Review\n",
    "    analysts = event.get('analysts', '')\n",
    "    if analysts:\n",
    "        for analyst in analysts:\n",
    "            print(f\"Name: {analyst.name}\")\n",
    "            print(f\"Affiliation: {analyst.affiliation}\")\n",
    "            print(f\"Role: {analyst.role}\")\n",
    "            print(f\"Description: {analyst.description}\")\n",
    "            print(\"-\" * 50)  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "2f81ad23-5656-43e6-b50a-0d7a4f69a60a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('human_feedback',)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Get state and look at next node\n",
    "state = graph.get_state(thread)\n",
    "state.next"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "72b2a402-fd10-4f26-9a32-3e3c0d4aaf76",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'configurable': {'thread_id': '1',\n",
       "  'checkpoint_ns': '',\n",
       "  'checkpoint_id': '1f0ad476-cb07-6cca-8002-853c2969aefa'}}"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We now update the state as if we are the human_feedback node\n",
    "graph.update_state(thread, {\"human_analyst_feedback\": \n",
    "                            \"Add in someone from a startup to add an entrepreneur perspective\"}, as_node=\"human_feedback\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "b8816eb9-9906-441b-b552-be71107db14f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name: Dr. Emily Carter\n",
      "Affiliation: Tech Innovators Inc.\n",
      "Role: Technology Adoption Specialist\n",
      "Description: Dr. Carter focuses on the technological advancements and integration of new frameworks like LangGraph. Her primary concern is how these frameworks can enhance efficiency and innovation in software development. She is motivated by the potential of LangGraph to streamline processes and improve the adaptability of agent-based systems.\n",
      "--------------------------------------------------\n",
      "Name: Mr. John Smith\n",
      "Affiliation: Global Business Solutions\n",
      "Role: Business Strategy Analyst\n",
      "Description: Mr. Smith analyzes the strategic business benefits of adopting new technologies such as LangGraph. His focus is on the competitive advantage and cost-effectiveness that LangGraph can offer to businesses. He is particularly interested in how LangGraph can drive business growth and improve market positioning.\n",
      "--------------------------------------------------\n",
      "Name: Ms. Sarah Lee\n",
      "Affiliation: Data Security Alliance\n",
      "Role: Cybersecurity Expert\n",
      "Description: Ms. Lee is dedicated to understanding the security implications of adopting new frameworks like LangGraph. Her main concern is ensuring that the integration of LangGraph does not compromise data security. She is motivated by the need to maintain robust security measures while leveraging the benefits of advanced agent frameworks.\n",
      "--------------------------------------------------\n",
      "Name: Alex Johnson\n",
      "Affiliation: Tech Innovators Inc.\n",
      "Role: Startup Entrepreneur\n",
      "Description: Alex is a co-founder of a tech startup that focuses on developing innovative AI solutions. With a keen interest in leveraging cutting-edge technologies to gain a competitive edge, Alex is particularly interested in how adopting LangGraph as an agent framework can streamline development processes, reduce costs, and accelerate time-to-market for new AI products.\n",
      "--------------------------------------------------\n",
      "Name: Dr. Emily Chen\n",
      "Affiliation: AI Research Institute\n",
      "Role: AI Researcher\n",
      "Description: Dr. Chen is a leading researcher in the field of artificial intelligence, with a focus on agent-based systems. Her work involves exploring the theoretical underpinnings and practical applications of AI frameworks. She is interested in the technical benefits of LangGraph, such as its scalability, flexibility, and how it enhances the performance of AI agents in complex environments.\n",
      "--------------------------------------------------\n",
      "Name: Michael Thompson\n",
      "Affiliation: Global Tech Solutions\n",
      "Role: Enterprise Technology Strategist\n",
      "Description: Michael is a technology strategist at a large enterprise, responsible for evaluating and integrating new technologies into the company's operations. He is focused on the strategic advantages of adopting LangGraph, including its potential to improve operational efficiency, enhance decision-making processes, and provide a robust platform for developing enterprise-level AI solutions.\n",
      "--------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "# Continue the graph execution\n",
    "for event in graph.stream(None, thread, stream_mode=\"values\"):\n",
    "    # Review\n",
    "    analysts = event.get('analysts', '')\n",
    "    if analysts:\n",
    "        for analyst in analysts:\n",
    "            print(f\"Name: {analyst.name}\")\n",
    "            print(f\"Affiliation: {analyst.affiliation}\")\n",
    "            print(f\"Role: {analyst.role}\")\n",
    "            print(f\"Description: {analyst.description}\")\n",
    "            print(\"-\" * 50) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "a43ac322-5926-4932-8653-68206fec0d2c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'configurable': {'thread_id': '1',\n",
       "  'checkpoint_ns': '',\n",
       "  'checkpoint_id': '1f0ad476-f7be-6ff2-8004-8506bc8ccc71'}}"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# If we are satisfied, then we simply supply no feedback\n",
    "further_feedack = None\n",
    "graph.update_state(thread, {\"human_analyst_feedback\": \n",
    "                            further_feedack}, as_node=\"human_feedback\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "ab034e65-aeee-4723-8d6d-74541b548425",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Continue the graph execution to end\n",
    "for event in graph.stream(None, thread, stream_mode=\"updates\"):\n",
    "    print(\"--Node--\")\n",
    "    node_name = next(iter(event.keys()))\n",
    "    print(node_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "2f204e8a-285c-4e46-8223-a695caec7764",
   "metadata": {},
   "outputs": [],
   "source": [
    "final_state = graph.get_state(thread)\n",
    "analysts = final_state.values.get('analysts')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "59704086-cb3b-42e9-8395-37be6f0d44e9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "final_state.next"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "95717ba3-aa00-48d6-bbb7-5fe4db5919bf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name: Alex Johnson\n",
      "Affiliation: Tech Innovators Inc.\n",
      "Role: Startup Entrepreneur\n",
      "Description: Alex is a co-founder of a tech startup that focuses on developing innovative AI solutions. With a keen interest in leveraging cutting-edge technologies to gain a competitive edge, Alex is particularly interested in how adopting LangGraph as an agent framework can streamline development processes, reduce costs, and accelerate time-to-market for new AI products.\n",
      "--------------------------------------------------\n",
      "Name: Dr. Emily Chen\n",
      "Affiliation: AI Research Institute\n",
      "Role: AI Researcher\n",
      "Description: Dr. Chen is a leading researcher in the field of artificial intelligence, with a focus on agent-based systems. Her work involves exploring the theoretical underpinnings and practical applications of AI frameworks. She is interested in the technical benefits of LangGraph, such as its scalability, flexibility, and how it enhances the performance of AI agents in complex environments.\n",
      "--------------------------------------------------\n",
      "Name: Michael Thompson\n",
      "Affiliation: Global Tech Solutions\n",
      "Role: Enterprise Technology Strategist\n",
      "Description: Michael is a technology strategist at a large enterprise, responsible for evaluating and integrating new technologies into the company's operations. He is focused on the strategic advantages of adopting LangGraph, including its potential to improve operational efficiency, enhance decision-making processes, and provide a robust platform for developing enterprise-level AI solutions.\n",
      "--------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "for analyst in analysts:\n",
    "    print(f\"Name: {analyst.name}\")\n",
    "    print(f\"Affiliation: {analyst.affiliation}\")\n",
    "    print(f\"Role: {analyst.role}\")\n",
    "    print(f\"Description: {analyst.description}\")\n",
    "    print(\"-\" * 50) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7d2498e4-20ae-4503-9dd0-a4165132b7a7",
   "metadata": {},
   "source": [
    "## Conduct Interview\n",
    "\n",
    "### Generate Question\n",
    "\n",
    "The analyst will ask questions to the expert."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "e5d5f559-f42e-442b-87cd-dbf0a91abf9c",
   "metadata": {},
   "outputs": [],
   "source": [
    "import operator\n",
    "from typing import  Annotated\n",
    "from langgraph.graph import MessagesState\n",
    "\n",
    "class InterviewState(MessagesState):\n",
    "    max_num_turns: int # Number turns of conversation\n",
    "    context: Annotated[list, operator.add] # Source docs\n",
    "    analyst: Analyst # Analyst asking questions\n",
    "    interview: str # Interview transcript\n",
    "    sections: list # Final key we duplicate in outer state for Send() API\n",
    "\n",
    "class SearchQuery(BaseModel):\n",
    "    search_query: str = Field(None, description=\"Search query for retrieval.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "1c2e71eb-07ad-4bea-aabc-dbaf551408c0",
   "metadata": {},
   "outputs": [],
   "source": [
    "question_instructions = \"\"\"You are an analyst tasked with interviewing an expert to learn about a specific topic. \n",
    "\n",
    "Your goal is boil down to interesting and specific insights related to your topic.\n",
    "\n",
    "1. Interesting: Insights that people will find surprising or non-obvious.\n",
    "        \n",
    "2. Specific: Insights that avoid generalities and include specific examples from the expert.\n",
    "\n",
    "Here is your topic of focus and set of goals: {goals}\n",
    "        \n",
    "Begin by introducing yourself using a name that fits your persona, and then ask your question.\n",
    "\n",
    "Continue to ask questions to drill down and refine your understanding of the topic.\n",
    "        \n",
    "When you are satisfied with your understanding, complete the interview with: \"Thank you so much for your help!\"\n",
    "\n",
    "Remember to stay in character throughout your response, reflecting the persona and goals provided to you.\"\"\"\n",
    "\n",
    "def generate_question(state: InterviewState):\n",
    "    \"\"\" Node to generate a question \"\"\"\n",
    "\n",
    "    # Get state\n",
    "    analyst = state[\"analyst\"]\n",
    "    messages = state[\"messages\"]\n",
    "\n",
    "    # Generate question \n",
    "    system_message = question_instructions.format(goals=analyst.persona)\n",
    "    question = llm.invoke([SystemMessage(content=system_message)]+messages)\n",
    "        \n",
    "    # Write messages to state\n",
    "    return {\"messages\": [question]}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "be2ff33a-6232-4a79-8a82-882a645394f5",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "### Generate Answer: Parallelization\n",
    "\n",
    "The expert will gather information from multiple sources in parallel to answer questions.\n",
    "\n",
    "For example, we can use:\n",
    "\n",
    "* Specific web sites e.g., via [`WebBaseLoader`](https://docs.langchain.com/oss/python/integrations/document_loaders/web_base)\n",
    "* Indexed documents e.g., via [RAG](https://docs.langchain.com/oss/python/langchain/retrieval)\n",
    "* Web search\n",
    "* Wikipedia search\n",
    "\n",
    "You can try different web search tools, like [Tavily](https://tavily.com/)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "606ea95b-e811-4299-8b66-835d4016c338",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "def _set_env(var: str):\n",
    "    if not os.environ.get(var):\n",
    "        os.environ[var] = getpass.getpass(f\"{var}: \")\n",
    "\n",
    "_set_env(\"TAVILY_API_KEY\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "c61ae74a-f838-4e97-8bd5-48ccd15b7789",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Web search tool\n",
    "from langchain_tavily import TavilySearch  # updated 1.0\n",
    "\n",
    "tavily_search = TavilySearch(max_results=3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "2d8f760b-5a1a-4fa9-a014-d3fb02bec51c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Wikipedia search tool\n",
    "from langchain_community.document_loaders import WikipediaLoader"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "06cb1603",
   "metadata": {},
   "source": [
    "Now, we create nodes to search the web and wikipedia.\n",
    "\n",
    "We'll also create a node to answer analyst questions.\n",
    "\n",
    "Finally, we'll create nodes to save the full interview and to write a summary (\"section\") of the interview."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "9c863768-2278-415b-aef1-96fd18c1b1cb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from langchain_core.messages import get_buffer_string\n",
    "\n",
    "# Search query writing\n",
    "search_instructions = SystemMessage(content=f\"\"\"You will be given a conversation between an analyst and an expert. \n",
    "\n",
    "Your goal is to generate a well-structured query for use in retrieval and / or web-search related to the conversation.\n",
    "        \n",
    "First, analyze the full conversation.\n",
    "\n",
    "Pay particular attention to the final question posed by the analyst.\n",
    "\n",
    "Convert this final question into a well-structured web search query\"\"\")\n",
    "\n",
    "def search_web(state: InterviewState):\n",
    "    \n",
    "    \"\"\" Retrieve docs from web search \"\"\"\n",
    "\n",
    "    # Search query\n",
    "    structured_llm = llm.with_structured_output(SearchQuery)\n",
    "    search_query = structured_llm.invoke([search_instructions]+state['messages'])\n",
    "    \n",
    "    # Search\n",
    "    #search_docs = tavily_search.invoke(search_query.search_query) # updated 1.0\n",
    "    data = tavily_search.invoke({\"query\": search_query.search_query})\n",
    "    search_docs = data.get(\"results\", data)\n",
    "    \n",
    "\n",
    "     # Format\n",
    "    formatted_search_docs = \"\\n\\n---\\n\\n\".join(\n",
    "        [\n",
    "            f'<Document href=\"{doc[\"url\"]}\"/>\\n{doc[\"content\"]}\\n</Document>'\n",
    "            for doc in search_docs\n",
    "        ]\n",
    "    )\n",
    "\n",
    "    return {\"context\": [formatted_search_docs]} \n",
    "\n",
    "def search_wikipedia(state: InterviewState):\n",
    "    \n",
    "    \"\"\" Retrieve docs from wikipedia \"\"\"\n",
    "\n",
    "    # Search query\n",
    "    structured_llm = llm.with_structured_output(SearchQuery)\n",
    "    search_query = structured_llm.invoke([search_instructions]+state['messages'])\n",
    "    \n",
    "    # Search\n",
    "    search_docs = WikipediaLoader(query=search_query.search_query, \n",
    "                                  load_max_docs=2).load()\n",
    "\n",
    "     # Format\n",
    "    formatted_search_docs = \"\\n\\n---\\n\\n\".join(\n",
    "        [\n",
    "            f'<Document source=\"{doc.metadata[\"source\"]}\" page=\"{doc.metadata.get(\"page\", \"\")}\"/>\\n{doc.page_content}\\n</Document>'\n",
    "            for doc in search_docs\n",
    "        ]\n",
    "    )\n",
    "\n",
    "    return {\"context\": [formatted_search_docs]} \n",
    "\n",
    "answer_instructions = \"\"\"You are an expert being interviewed by an analyst.\n",
    "\n",
    "Here is analyst area of focus: {goals}. \n",
    "        \n",
    "You goal is to answer a question posed by the interviewer.\n",
    "\n",
    "To answer question, use this context:\n",
    "        \n",
    "{context}\n",
    "\n",
    "When answering questions, follow these guidelines:\n",
    "        \n",
    "1. Use only the information provided in the context. \n",
    "        \n",
    "2. Do not introduce external information or make assumptions beyond what is explicitly stated in the context.\n",
    "\n",
    "3. The context contain sources at the topic of each individual document.\n",
    "\n",
    "4. Include these sources your answer next to any relevant statements. For example, for source # 1 use [1]. \n",
    "\n",
    "5. List your sources in order at the bottom of your answer. [1] Source 1, [2] Source 2, etc\n",
    "        \n",
    "6. If the source is: <Document source=\"assistant/docs/llama3_1.pdf\" page=\"7\"/>' then just list: \n",
    "        \n",
    "[1] assistant/docs/llama3_1.pdf, page 7 \n",
    "        \n",
    "And skip the addition of the brackets as well as the Document source preamble in your citation.\"\"\"\n",
    "\n",
    "def generate_answer(state: InterviewState):\n",
    "    \n",
    "    \"\"\" Node to answer a question \"\"\"\n",
    "\n",
    "    # Get state\n",
    "    analyst = state[\"analyst\"]\n",
    "    messages = state[\"messages\"]\n",
    "    context = state[\"context\"]\n",
    "\n",
    "    # Answer question\n",
    "    system_message = answer_instructions.format(goals=analyst.persona, context=context)\n",
    "    answer = llm.invoke([SystemMessage(content=system_message)]+messages)\n",
    "            \n",
    "    # Name the message as coming from the expert\n",
    "    answer.name = \"expert\"\n",
    "    \n",
    "    # Append it to state\n",
    "    return {\"messages\": [answer]}\n",
    "\n",
    "def save_interview(state: InterviewState):\n",
    "    \n",
    "    \"\"\" Save interviews \"\"\"\n",
    "\n",
    "    # Get messages\n",
    "    messages = state[\"messages\"]\n",
    "    \n",
    "    # Convert interview to a string\n",
    "    interview = get_buffer_string(messages)\n",
    "    \n",
    "    # Save to interviews key\n",
    "    return {\"interview\": interview}\n",
    "\n",
    "def route_messages(state: InterviewState, \n",
    "                   name: str = \"expert\"):\n",
    "\n",
    "    \"\"\" Route between question and answer \"\"\"\n",
    "    \n",
    "    # Get messages\n",
    "    messages = state[\"messages\"]\n",
    "    max_num_turns = state.get('max_num_turns',2)\n",
    "\n",
    "    # Check the number of expert answers \n",
    "    num_responses = len(\n",
    "        [m for m in messages if isinstance(m, AIMessage) and m.name == name]\n",
    "    )\n",
    "\n",
    "    # End if expert has answered more than the max turns\n",
    "    if num_responses >= max_num_turns:\n",
    "        return 'save_interview'\n",
    "\n",
    "    # This router is run after each question - answer pair \n",
    "    # Get the last question asked to check if it signals the end of discussion\n",
    "    last_question = messages[-2]\n",
    "    \n",
    "    if \"Thank you so much for your help\" in last_question.content:\n",
    "        return 'save_interview'\n",
    "    return \"ask_question\"\n",
    "\n",
    "section_writer_instructions = \"\"\"You are an expert technical writer. \n",
    "            \n",
    "Your task is to create a short, easily digestible section of a report based on a set of source documents.\n",
    "\n",
    "1. Analyze the content of the source documents: \n",
    "- The name of each source document is at the start of the document, with the <Document tag.\n",
    "        \n",
    "2. Create a report structure using markdown formatting:\n",
    "- Use ## for the section title\n",
    "- Use ### for sub-section headers\n",
    "        \n",
    "3. Write the report following this structure:\n",
    "a. Title (## header)\n",
    "b. Summary (### header)\n",
    "c. Sources (### header)\n",
    "\n",
    "4. Make your title engaging based upon the focus area of the analyst: \n",
    "{focus}\n",
    "\n",
    "5. For the summary section:\n",
    "- Set up summary with general background / context related to the focus area of the analyst\n",
    "- Emphasize what is novel, interesting, or surprising about insights gathered from the interview\n",
    "- Create a numbered list of source documents, as you use them\n",
    "- Do not mention the names of interviewers or experts\n",
    "- Aim for approximately 400 words maximum\n",
    "- Use numbered sources in your report (e.g., [1], [2]) based on information from source documents\n",
    "        \n",
    "6. In the Sources section:\n",
    "- Include all sources used in your report\n",
    "- Provide full links to relevant websites or specific document paths\n",
    "- Separate each source by a newline. Use two spaces at the end of each line to create a newline in Markdown.\n",
    "- It will look like:\n",
    "\n",
    "### Sources\n",
    "[1] Link or Document name\n",
    "[2] Link or Document name\n",
    "\n",
    "7. Be sure to combine sources. For example this is not correct:\n",
    "\n",
    "[3] https://ai.meta.com/blog/meta-llama-3-1/\n",
    "[4] https://ai.meta.com/blog/meta-llama-3-1/\n",
    "\n",
    "There should be no redundant sources. It should simply be:\n",
    "\n",
    "[3] https://ai.meta.com/blog/meta-llama-3-1/\n",
    "        \n",
    "8. Final review:\n",
    "- Ensure the report follows the required structure\n",
    "- Include no preamble before the title of the report\n",
    "- Check that all guidelines have been followed\"\"\"\n",
    "\n",
    "def write_section(state: InterviewState):\n",
    "\n",
    "    \"\"\" Node to answer a question \"\"\"\n",
    "\n",
    "    # Get state\n",
    "    interview = state[\"interview\"]\n",
    "    context = state[\"context\"]\n",
    "    analyst = state[\"analyst\"]\n",
    "   \n",
    "    # Write section using either the gathered source docs from interview (context) or the interview itself (interview)\n",
    "    system_message = section_writer_instructions.format(focus=analyst.description)\n",
    "    section = llm.invoke([SystemMessage(content=system_message)]+[HumanMessage(content=f\"Use this source to write your section: {context}\")]) \n",
    "                \n",
    "    # Append it to state\n",
    "    return {\"sections\": [section.content]}\n",
    "\n",
    "# Add nodes and edges \n",
    "interview_builder = StateGraph(InterviewState)\n",
    "interview_builder.add_node(\"ask_question\", generate_question)\n",
    "interview_builder.add_node(\"search_web\", search_web)\n",
    "interview_builder.add_node(\"search_wikipedia\", search_wikipedia)\n",
    "interview_builder.add_node(\"answer_question\", generate_answer)\n",
    "interview_builder.add_node(\"save_interview\", save_interview)\n",
    "interview_builder.add_node(\"write_section\", write_section)\n",
    "\n",
    "# Flow\n",
    "interview_builder.add_edge(START, \"ask_question\")\n",
    "interview_builder.add_edge(\"ask_question\", \"search_web\")\n",
    "interview_builder.add_edge(\"ask_question\", \"search_wikipedia\")\n",
    "interview_builder.add_edge(\"search_web\", \"answer_question\")\n",
    "interview_builder.add_edge(\"search_wikipedia\", \"answer_question\")\n",
    "interview_builder.add_conditional_edges(\"answer_question\", route_messages,['ask_question','save_interview'])\n",
    "interview_builder.add_edge(\"save_interview\", \"write_section\")\n",
    "interview_builder.add_edge(\"write_section\", END)\n",
    "\n",
    "# Interview \n",
    "memory = MemorySaver()\n",
    "interview_graph = interview_builder.compile(checkpointer=memory).with_config(run_name=\"Conduct Interviews\")\n",
    "\n",
    "# View\n",
    "display(Image(interview_graph.get_graph().draw_mermaid_png()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "50f382f1-6e93-48d0-a44a-1094d26ccb1e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Analyst(affiliation='Tech Innovators Inc.', name='Alex Johnson', role='Startup Entrepreneur', description='Alex is a co-founder of a tech startup that focuses on developing innovative AI solutions. With a keen interest in leveraging cutting-edge technologies to gain a competitive edge, Alex is particularly interested in how adopting LangGraph as an agent framework can streamline development processes, reduce costs, and accelerate time-to-market for new AI products.')"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Pick one analyst\n",
    "analysts[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3750ac4f-f458-4b2d-8bad-32ce34895758",
   "metadata": {},
   "source": [
    "Here, we run the interview passing an index of the llama3.1 paper, which is related to our topic."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "b2242d4e-8430-4de9-8cf7-3ad2f9a22b28",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "## Accelerating AI Product Development with LangGraph\n",
       "\n",
       "### Summary\n",
       "\n",
       "In the rapidly evolving landscape of AI technology, startups like Alex's are constantly seeking innovative frameworks to streamline development processes, reduce costs, and accelerate time-to-market for new AI products. LangGraph emerges as a compelling solution, offering a graph-based architecture that enhances the development of AI agents by enabling complex decision-making and multi-agent coordination. This report explores the advantages of adopting LangGraph as an agent framework, highlighting its potential to revolutionize AI product development.\n",
       "\n",
       "LangGraph distinguishes itself from traditional linear coding frameworks by allowing developers to construct agent behaviors in a graphical form. This approach is particularly beneficial for AI agents that require backtracking or managing complex multi-step tasks [1]. The framework's orchestration capabilities, which include both declarative and imperative APIs, provide a robust platform for developing AI solutions that require short-term and long-term memory storage, human-in-the-loop processes, and fault tolerance [2]. These features are crucial for creating reliable, production-ready AI systems.\n",
       "\n",
       "One of the most novel aspects of LangGraph is its ability to maintain state and handle cyclical processes, which traditional frameworks often struggle with. This capability allows AI agents to revisit previous steps, adapt to changing conditions, and maintain context throughout extended interactions [3]. For instance, a global technology company successfully implemented a LangGraph-based customer support agent, significantly improving their approach to complex technical issues [3].\n",
       "\n",
       "LangGraph's integration with the LangChain ecosystem further enhances its utility by providing developers with the building blocks to transition from prototype to production-ready systems. This integration supports the development of multi-turn conversation systems and collaborative agent ecosystems where context and decision-making are paramount [4]. By leveraging LangGraph, startups can move beyond the limitations of single-turn prompts, orchestrating agent interactions and managing memory through a graph-based architecture [5].\n",
       "\n",
       "In summary, LangGraph offers a transformative approach to AI agent development, enabling startups to streamline their processes and bring innovative AI products to market more efficiently. Its graph-based architecture, combined with the orchestration capabilities and integration with LangChain, positions LangGraph as a leading framework for developing stateful, complex AI systems.\n",
       "\n",
       "### Sources\n",
       "[1] https://community.latenode.com/t/what-are-the-main-advantages-of-choosing-langgraph-for-ai-agent-development/31000  \n",
       "[2] https://blog.langchain.com/how-to-think-about-agent-frameworks/  \n",
       "[3] https://blog.agen.cy/p/agency-revolutionizing-ai-development  \n",
       "[4] https://milvus.io/blog/langchain-vs-langgraph.md  \n",
       "[5] https://www.scalablepath.com/machine-learning/langgraph  "
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import Markdown\n",
    "messages = [HumanMessage(f\"So you said you were writing an article on {topic}?\")]\n",
    "thread = {\"configurable\": {\"thread_id\": \"1\"}}\n",
    "interview = interview_graph.invoke({\"analyst\": analysts[0], \"messages\": messages, \"max_num_turns\": 2}, thread)\n",
    "Markdown(interview['sections'][0])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3b739e87-68bb-4e96-a86a-704e84240a6c",
   "metadata": {},
   "source": [
    "### Parallelze interviews: Map-Reduce\n",
    "\n",
    "We parallelize the interviews via the `Send()` API, a map step.\n",
    "\n",
    "We combine them into the report body in a reduce step.\n",
    "\n",
    "### Finalize\n",
    "\n",
    "We add a final step to write an intro and conclusion to the final report."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "6a0042f9-5b9f-441a-9e8d-7d8189f44140",
   "metadata": {},
   "outputs": [],
   "source": [
    "import operator\n",
    "from typing import List, Annotated\n",
    "from typing_extensions import TypedDict\n",
    "\n",
    "class ResearchGraphState(TypedDict):\n",
    "    topic: str # Research topic\n",
    "    max_analysts: int # Number of analysts\n",
    "    human_analyst_feedback: str # Human feedback\n",
    "    analysts: List[Analyst] # Analyst asking questions\n",
    "    sections: Annotated[list, operator.add] # Send() API key\n",
    "    introduction: str # Introduction for the final report\n",
    "    content: str # Content for the final report\n",
    "    conclusion: str # Conclusion for the final report\n",
    "    final_report: str # Final report"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "c2224592-d2ff-469d-97bd-928809f896d7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from langgraph.types import Send # updated in 1.0\n",
    "def initiate_all_interviews(state: ResearchGraphState):\n",
    "    \"\"\" This is the \"map\" step where we run each interview sub-graph using Send API \"\"\"    \n",
    "\n",
    "    # Check if human feedback\n",
    "    human_analyst_feedback=state.get('human_analyst_feedback')\n",
    "    if human_analyst_feedback:\n",
    "        # Return to create_analysts\n",
    "        return \"create_analysts\"\n",
    "\n",
    "    # Otherwise kick off interviews in parallel via Send() API\n",
    "    else:\n",
    "        topic = state[\"topic\"]\n",
    "        return [Send(\"conduct_interview\", {\"analyst\": analyst,\n",
    "                                           \"messages\": [HumanMessage(\n",
    "                                               content=f\"So you said you were writing an article on {topic}?\"\n",
    "                                           )\n",
    "                                                       ]}) for analyst in state[\"analysts\"]]\n",
    "\n",
    "report_writer_instructions = \"\"\"You are a technical writer creating a report on this overall topic: \n",
    "\n",
    "{topic}\n",
    "    \n",
    "You have a team of analysts. Each analyst has done two things: \n",
    "\n",
    "1. They conducted an interview with an expert on a specific sub-topic.\n",
    "2. They write up their finding into a memo.\n",
    "\n",
    "Your task: \n",
    "\n",
    "1. You will be given a collection of memos from your analysts.\n",
    "2. Think carefully about the insights from each memo.\n",
    "3. Consolidate these into a crisp overall summary that ties together the central ideas from all of the memos. \n",
    "4. Summarize the central points in each memo into a cohesive single narrative.\n",
    "\n",
    "To format your report:\n",
    " \n",
    "1. Use markdown formatting. \n",
    "2. Include no pre-amble for the report.\n",
    "3. Use no sub-heading. \n",
    "4. Start your report with a single title header: ## Insights\n",
    "5. Do not mention any analyst names in your report.\n",
    "6. Preserve any citations in the memos, which will be annotated in brackets, for example [1] or [2].\n",
    "7. Create a final, consolidated list of sources and add to a Sources section with the `## Sources` header.\n",
    "8. List your sources in order and do not repeat.\n",
    "\n",
    "[1] Source 1\n",
    "[2] Source 2\n",
    "\n",
    "Here are the memos from your analysts to build your report from: \n",
    "\n",
    "{context}\"\"\"\n",
    "\n",
    "def write_report(state: ResearchGraphState):\n",
    "    # Full set of sections\n",
    "    sections = state[\"sections\"]\n",
    "    topic = state[\"topic\"]\n",
    "\n",
    "    # Concat all sections together\n",
    "    formatted_str_sections = \"\\n\\n\".join([f\"{section}\" for section in sections])\n",
    "    \n",
    "    # Summarize the sections into a final report\n",
    "    system_message = report_writer_instructions.format(topic=topic, context=formatted_str_sections)    \n",
    "    report = llm.invoke([SystemMessage(content=system_message)]+[HumanMessage(content=f\"Write a report based upon these memos.\")]) \n",
    "    return {\"content\": report.content}\n",
    "\n",
    "intro_conclusion_instructions = \"\"\"You are a technical writer finishing a report on {topic}\n",
    "\n",
    "You will be given all of the sections of the report.\n",
    "\n",
    "You job is to write a crisp and compelling introduction or conclusion section.\n",
    "\n",
    "The user will instruct you whether to write the introduction or conclusion.\n",
    "\n",
    "Include no pre-amble for either section.\n",
    "\n",
    "Target around 100 words, crisply previewing (for introduction) or recapping (for conclusion) all of the sections of the report.\n",
    "\n",
    "Use markdown formatting. \n",
    "\n",
    "For your introduction, create a compelling title and use the # header for the title.\n",
    "\n",
    "For your introduction, use ## Introduction as the section header. \n",
    "\n",
    "For your conclusion, use ## Conclusion as the section header.\n",
    "\n",
    "Here are the sections to reflect on for writing: {formatted_str_sections}\"\"\"\n",
    "\n",
    "def write_introduction(state: ResearchGraphState):\n",
    "    # Full set of sections\n",
    "    sections = state[\"sections\"]\n",
    "    topic = state[\"topic\"]\n",
    "\n",
    "    # Concat all sections together\n",
    "    formatted_str_sections = \"\\n\\n\".join([f\"{section}\" for section in sections])\n",
    "    \n",
    "    # Summarize the sections into a final report\n",
    "    \n",
    "    instructions = intro_conclusion_instructions.format(topic=topic, formatted_str_sections=formatted_str_sections)    \n",
    "    intro = llm.invoke([instructions]+[HumanMessage(content=f\"Write the report introduction\")]) \n",
    "    return {\"introduction\": intro.content}\n",
    "\n",
    "def write_conclusion(state: ResearchGraphState):\n",
    "    # Full set of sections\n",
    "    sections = state[\"sections\"]\n",
    "    topic = state[\"topic\"]\n",
    "\n",
    "    # Concat all sections together\n",
    "    formatted_str_sections = \"\\n\\n\".join([f\"{section}\" for section in sections])\n",
    "    \n",
    "    # Summarize the sections into a final report\n",
    "    \n",
    "    instructions = intro_conclusion_instructions.format(topic=topic, formatted_str_sections=formatted_str_sections)    \n",
    "    conclusion = llm.invoke([instructions]+[HumanMessage(content=f\"Write the report conclusion\")]) \n",
    "    return {\"conclusion\": conclusion.content}\n",
    "\n",
    "def finalize_report(state: ResearchGraphState):\n",
    "    \"\"\" The is the \"reduce\" step where we gather all the sections, combine them, and reflect on them to write the intro/conclusion \"\"\"\n",
    "    # Save full final report\n",
    "    content = state[\"content\"]\n",
    "    if content.startswith(\"## Insights\"):\n",
    "        content = content.strip(\"## Insights\")\n",
    "    if \"## Sources\" in content:\n",
    "        try:\n",
    "            content, sources = content.split(\"\\n## Sources\\n\")\n",
    "        except:\n",
    "            sources = None\n",
    "    else:\n",
    "        sources = None\n",
    "\n",
    "    final_report = state[\"introduction\"] + \"\\n\\n---\\n\\n\" + content + \"\\n\\n---\\n\\n\" + state[\"conclusion\"]\n",
    "    if sources is not None:\n",
    "        final_report += \"\\n\\n## Sources\\n\" + sources\n",
    "    return {\"final_report\": final_report}\n",
    "\n",
    "# Add nodes and edges \n",
    "builder = StateGraph(ResearchGraphState)\n",
    "builder.add_node(\"create_analysts\", create_analysts)\n",
    "builder.add_node(\"human_feedback\", human_feedback)\n",
    "builder.add_node(\"conduct_interview\", interview_builder.compile())\n",
    "builder.add_node(\"write_report\",write_report)\n",
    "builder.add_node(\"write_introduction\",write_introduction)\n",
    "builder.add_node(\"write_conclusion\",write_conclusion)\n",
    "builder.add_node(\"finalize_report\",finalize_report)\n",
    "\n",
    "# Logic\n",
    "builder.add_edge(START, \"create_analysts\")\n",
    "builder.add_edge(\"create_analysts\", \"human_feedback\")\n",
    "builder.add_conditional_edges(\"human_feedback\", initiate_all_interviews, [\"create_analysts\", \"conduct_interview\"])\n",
    "builder.add_edge(\"conduct_interview\", \"write_report\")\n",
    "builder.add_edge(\"conduct_interview\", \"write_introduction\")\n",
    "builder.add_edge(\"conduct_interview\", \"write_conclusion\")\n",
    "builder.add_edge([\"write_conclusion\", \"write_report\", \"write_introduction\"], \"finalize_report\")\n",
    "builder.add_edge(\"finalize_report\", END)\n",
    "\n",
    "# Compile\n",
    "memory = MemorySaver()\n",
    "graph = builder.compile(interrupt_before=['human_feedback'], checkpointer=memory)\n",
    "display(Image(graph.get_graph(xray=1).draw_mermaid_png()))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1b64ba9a-2b5e-40e1-a778-0f635aa3f6d0",
   "metadata": {},
   "source": [
    "Let's ask an open-ended question about LangGraph."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "362932ee-4106-4a2d-a32d-b812eafcf9df",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name: Dr. Emily Carter\n",
      "Affiliation: Tech Innovators Inc.\n",
      "Role: Technology Adoption Specialist\n",
      "Description: Dr. Carter focuses on the strategic benefits of adopting new technologies like LangGraph. She is particularly interested in how LangGraph can streamline processes, improve efficiency, and provide a competitive edge to organizations. Her analysis often includes case studies and data-driven insights to support the adoption of innovative frameworks.\n",
      "--------------------------------------------------\n",
      "Name: Mr. Raj Patel\n",
      "Affiliation: Data Security Solutions\n",
      "Role: Cybersecurity Analyst\n",
      "Description: Mr. Patel is concerned with the security implications of adopting new frameworks such as LangGraph. His focus is on understanding how LangGraph can enhance or compromise data security within an organization. He evaluates the framework's security features, potential vulnerabilities, and compliance with industry standards.\n",
      "--------------------------------------------------\n",
      "Name: Dr. Lisa Nguyen\n",
      "Affiliation: AI Ethics Consortium\n",
      "Role: Ethical AI Researcher\n",
      "Description: Dr. Nguyen examines the ethical considerations of implementing agent frameworks like LangGraph. Her work involves assessing the impact of LangGraph on privacy, bias, and transparency in AI systems. She advocates for responsible AI practices and ensures that the adoption of such technologies aligns with ethical guidelines and societal values.\n",
      "--------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "# Inputs\n",
    "max_analysts = 3 \n",
    "topic = \"The benefits of adopting LangGraph as an agent framework\"\n",
    "thread = {\"configurable\": {\"thread_id\": \"1\"}}\n",
    "\n",
    "# Run the graph until the first interruption\n",
    "for event in graph.stream({\"topic\":topic,\n",
    "                           \"max_analysts\":max_analysts}, \n",
    "                          thread, \n",
    "                          stream_mode=\"values\"):\n",
    "    \n",
    "    analysts = event.get('analysts', '')\n",
    "    if analysts:\n",
    "        for analyst in analysts:\n",
    "            print(f\"Name: {analyst.name}\")\n",
    "            print(f\"Affiliation: {analyst.affiliation}\")\n",
    "            print(f\"Role: {analyst.role}\")\n",
    "            print(f\"Description: {analyst.description}\")\n",
    "            print(\"-\" * 50)  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "ac521a5f-5a4f-44f9-8af9-d05228e20882",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'configurable': {'thread_id': '1',\n",
       "  'checkpoint_ns': '',\n",
       "  'checkpoint_id': '1f0ad478-2e3b-6372-8002-87845d0b55a4'}}"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We now update the state as if we are the human_feedback node\n",
    "graph.update_state(thread, {\"human_analyst_feedback\": \n",
    "                                \"Add in the CEO of gen ai native startup\"}, as_node=\"human_feedback\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "a3be311f-62ee-49e7-b037-75c53d8960a8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name: Dr. Emily Carter\n",
      "Affiliation: Tech Innovators Inc.\n",
      "Role: Technology Adoption Specialist\n",
      "Description: Dr. Carter focuses on the strategic benefits of adopting new technologies like LangGraph. She is particularly interested in how LangGraph can streamline processes, improve efficiency, and provide a competitive edge to organizations. Her analysis often includes case studies and data-driven insights to support the adoption of innovative frameworks.\n",
      "--------------------------------------------------\n",
      "Name: Mr. Raj Patel\n",
      "Affiliation: Data Security Solutions\n",
      "Role: Cybersecurity Analyst\n",
      "Description: Mr. Patel is concerned with the security implications of adopting new frameworks such as LangGraph. His focus is on understanding how LangGraph can enhance or compromise data security within an organization. He evaluates the framework's security features, potential vulnerabilities, and compliance with industry standards.\n",
      "--------------------------------------------------\n",
      "Name: Dr. Lisa Nguyen\n",
      "Affiliation: AI Ethics Consortium\n",
      "Role: Ethical AI Researcher\n",
      "Description: Dr. Nguyen examines the ethical considerations of implementing agent frameworks like LangGraph. Her work involves assessing the impact of LangGraph on privacy, bias, and transparency in AI systems. She advocates for responsible AI practices and ensures that the adoption of such technologies aligns with ethical guidelines and societal values.\n",
      "--------------------------------------------------\n",
      "Name: Dr. Emily Carter\n",
      "Affiliation: LangGraph Research Institute\n",
      "Role: Framework Efficiency Specialist\n",
      "Description: Dr. Carter focuses on the technical efficiencies and performance improvements that LangGraph offers as an agent framework. Her primary concern is how LangGraph can optimize computational resources and improve the speed and accuracy of AI models. She is motivated by the potential to enhance AI systems' capabilities while reducing operational costs.\n",
      "--------------------------------------------------\n",
      "Name: Raj Patel\n",
      "Affiliation: Tech Innovators Magazine\n",
      "Role: Industry Trends Analyst\n",
      "Description: Raj Patel analyzes the broader industry trends and the strategic advantages of adopting LangGraph. His focus is on how LangGraph positions itself within the competitive landscape of AI frameworks and its potential to drive innovation. He is particularly interested in how LangGraph can influence market dynamics and the adoption rates among tech companies.\n",
      "--------------------------------------------------\n",
      "Name: Sophia Zhang\n",
      "Affiliation: AI Pioneers Inc.\n",
      "Role: CEO of Gen AI Native Startup\n",
      "Description: Sophia Zhang is the CEO of a startup that is native to generative AI technologies. Her focus is on the practical applications and business benefits of integrating LangGraph into her company's operations. She is concerned with how LangGraph can enhance product offerings, improve customer experiences, and provide a competitive edge in the rapidly evolving AI market. Her motivation is to leverage cutting-edge technology to drive business growth and innovation.\n",
      "--------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "# Check\n",
    "for event in graph.stream(None, thread, stream_mode=\"values\"):\n",
    "    analysts = event.get('analysts', '')\n",
    "    if analysts:\n",
    "        for analyst in analysts:\n",
    "            print(f\"Name: {analyst.name}\")\n",
    "            print(f\"Affiliation: {analyst.affiliation}\")\n",
    "            print(f\"Role: {analyst.role}\")\n",
    "            print(f\"Description: {analyst.description}\")\n",
    "            print(\"-\" * 50)  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "0af41f54-88d9-4597-98b0-444c08322095",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'configurable': {'thread_id': '1',\n",
       "  'checkpoint_ns': '',\n",
       "  'checkpoint_id': '1f0ad478-5521-6a86-8004-054b9bf88282'}}"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Confirm we are happy\n",
    "graph.update_state(thread, {\"human_analyst_feedback\": \n",
    "                            None}, as_node=\"human_feedback\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "37123ca7-c20b-43c1-9a71-39ba344e7ca6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--Node--\n",
      "conduct_interview\n",
      "--Node--\n",
      "conduct_interview\n",
      "--Node--\n",
      "conduct_interview\n",
      "--Node--\n",
      "write_conclusion\n",
      "--Node--\n",
      "write_introduction\n",
      "--Node--\n",
      "write_report\n",
      "--Node--\n",
      "finalize_report\n"
     ]
    }
   ],
   "source": [
    "# Continue\n",
    "for event in graph.stream(None, thread, stream_mode=\"updates\"):\n",
    "    print(\"--Node--\")\n",
    "    node_name = next(iter(event.keys()))\n",
    "    print(node_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "f8f66ad8-80fd-4eb2-96b6-6ae9dffd060c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "# LangGraph: Revolutionizing AI Agent Development\n",
       "\n",
       "## Introduction\n",
       "\n",
       "In the dynamic realm of AI development, LangGraph emerges as a transformative agent framework, offering unparalleled efficiency and capability enhancements. By adopting a graphical approach, LangGraph excels in managing complex, multi-step tasks, crucial for sophisticated AI agents. It integrates declarative and imperative APIs, supporting stateful, multi-agent applications with features like memory storage and fault tolerance. This framework not only reduces development time but also improves system quality, seamlessly integrating with large language models to enhance user experience. LangGraph's strategic advantages, including hybrid integration and open-source infrastructure, position it as a pivotal player in driving business growth and innovation across industries.\n",
       "\n",
       "---\n",
       "\n",
       "\n",
       "\n",
       "LangGraph emerges as a transformative agent framework in the AI landscape, offering significant benefits in enhancing AI efficiency, providing strategic advantages, and fostering business growth and innovation. Its graphical approach to constructing agent behaviors allows for the management of complex, multi-step tasks with backtracking and conditional branching, which is essential for developing sophisticated AI agents capable of operating autonomously and efficiently [1]. This graphical representation simplifies the design and implementation of complex workflows, reducing development time and improving system quality [4].\n",
       "\n",
       "LangGraph's orchestration framework integrates both declarative and imperative APIs, supporting features such as short-term and long-term memory storage, human-in-the-loop processes, and fault tolerance. These capabilities are crucial for maintaining context and ensuring the reliability of AI workflows, making LangGraph a robust foundation for building stateful, multi-agent applications [2]. The framework's ability to integrate seamlessly with large language models (LLMs) further enhances its utility, enabling the creation of intelligent AI agents that can understand and generate human language, thus improving user experience and operational efficiency across various industries [5].\n",
       "\n",
       "Strategically, LangGraph stands out for its ability to handle complex conditional logic and multi-step reasoning, making it ideal for applications requiring advanced state management and long-term system evolution. This positions LangGraph as a preferred choice for enterprises with experienced AI/ML engineers, supporting extended development cycles for sophisticated capabilities [2]. Its potential for hybrid integration with other frameworks allows organizations to create comprehensive, enterprise-ready AI solutions, facilitating gradual migration from existing implementations and risk mitigation through incremental adoption [2].\n",
       "\n",
       "LangGraph's open-source nature and its foundation within the LangChain ecosystem enhance its appeal, providing a robust infrastructure for stateful agents and supporting integration with diverse data sources, APIs, and workflows. This flexibility and modularity make LangGraph not just a tool but a platform that others can build upon, enabling the deployment of multi-agent applications across a wide range of businesses [4].\n",
       "\n",
       "In conclusion, LangGraph offers a unique set of tools and structures that empower businesses to harness the full potential of AI technologies. By integrating LangGraph into their operations, companies can enhance their product offerings, improve customer experiences, and maintain a competitive edge in the AI market. Its graphical approach, robust orchestration capabilities, and strategic advantages position LangGraph as a leading framework for optimizing AI systems' performance and driving innovation across industries.\n",
       "\n",
       "\n",
       "---\n",
       "\n",
       "## Conclusion\n",
       "\n",
       "LangGraph emerges as a transformative agent framework in the AI landscape, offering significant advantages for optimizing AI systems. By employing a graphical approach, LangGraph enhances the efficiency and capability of AI models, particularly in managing complex, multi-step tasks. Its robust orchestration framework, integrating declarative and imperative APIs, supports stateful, multi-agent applications with features like memory storage and fault tolerance. This not only reduces development time but also improves system quality and operational efficiency. LangGraph's seamless integration with large language models further empowers businesses to innovate and maintain a competitive edge, making it a strategic asset for AI-driven growth and innovation.\n",
       "\n",
       "## Sources\n",
       "[1] https://community.latenode.com/t/what-are-the-main-advantages-of-choosing-langgraph-for-ai-agent-development/31000  \n",
       "[2] https://blog.langchain.com/how-to-think-about-agent-frameworks/  \n",
       "[3] https://blog.algoanalytics.com/2025/05/21/langgraph-the-framework-for-intelligent-ai-workflows/  \n",
       "[4] https://medium.com/@ken_lin/langgraph-a-framework-for-building-stateful-multi-agent-llm-applications-a51d5eb68d03  \n",
       "[5] https://www.rapidinnovation.io/post/ai-agents-in-langgraph  \n",
       "[6] https://artizen.com/insights/thought-leadership/ai-agent-frameworks  \n",
       "[7] https://www.leanware.co/insights/langchain-vs-langgraph-comparison  \n",
       "[8] https://interviewkickstart.com/blogs/articles/langgraph-for-retail-ai-agent  \n",
       "[9] https://medium.com/@takafumi.endo/langchain-why-its-the-foundation-of-ai-agent-development-in-the-enterprise-era-f082717c56d3  \n",
       "[10] https://www.scalablepath.com/machine-learning/langgrap"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import Markdown\n",
    "final_state = graph.get_state(thread)\n",
    "report = final_state.values.get('final_report')\n",
    "Markdown(report)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e9bf8edd-fb42-496c-9bdb-3f5d7b4d79d3",
   "metadata": {},
   "source": [
    "We can look at the trace:\n",
    "\n",
    "https://smith.langchain.com/public/2933a7bb-bcef-4d2d-9b85-cc735b22ca0c/r"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "808bd094",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.13.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
